package utils

import (
	"Yasuo/conf"
	"container/list"
	"errors"
	"fmt"
)

// 判断是不是基础运算

// 基本的计算栈操作
// 一个操作符，俩操作数
// 只是对加减乘除有效
func (u *Utils)CalcTopStack(OPD *list.List, OPT *list.List) error {
	var (
		opt interface{}
		sopt string
		oneOPD interface{}
		twoOPD interface{}
		foneOPD float64
		ftwOPD float64
		ok bool
		err error
		result float64
	)


	if opt, err = u.RemoveLast(OPT); err != nil {
		return err
	}
	if sopt, ok = opt.(string); !ok {
		return errors.New("opt类型转换失败哦")
	}
	//fmt.Println("______________________", sopt)
	
	if oneOPD, err = u.RemoveLast(OPD); err != nil {
		return err
	}
	if foneOPD, ok = oneOPD.(float64); !ok {
		return errors.New("float类型转换失败哦")
	}
	
	if twoOPD, err = u.RemoveLast(OPD); err != nil {
		return err
	}
	if ftwOPD, ok = twoOPD.(float64); !ok {
		return errors.New("float类型转换失败")
	}

	result = 0
	switch sopt {
	case conf.BaseOPTAddd:
		result = foneOPD + ftwOPD
		//fmt.Println("结果==============",foneOPD, ftwOPD, result)
		u.PushBack(OPD, result)
	case conf.BaseOPTMult:
		result = foneOPD * ftwOPD
	case conf.BaseOPTSub: // - 操作
		result = ftwOPD - foneOPD
		u.PushBack(OPD, result)
	default:
		fmt.Println("没有这个基本运算", sopt)
		return errors.New("不是运算")
	}

	return nil
}


// 更正边界操作数入栈
// 1. 判断是减号，就 v = 0 -v
func (u *Utils)UpdateOPD(OPD ,OPT *list.List) error  {
	var (
		opt interface{}
		sopt string
		err error
		ok bool
		opd interface{}
		fopd float64
		resultOPD float64
		resultOPT string
	)

	if opt, err = u.RemoveLast(OPT); err != nil {
		fmt.Println("前面没有操作符")
		return nil
	}
	if sopt, ok = opt.(string); !ok {
		return errors.New("类型转换错误")
	}

	if opd, err = u.RemoveLast(OPD); err != nil {
		return err
	}
	if fopd, ok = opd.(float64); !ok {
		return errors.New("类型转换错误")
	}

	switch sopt {
	case conf.BaseOPTAddd:
		resultOPD = fopd
		resultOPT = conf.BaseOPTAddd
	case conf.BaseOPTSub: // 减法变号
		//fmt.Println("遇到减法")
		resultOPD = 0 - fopd
		resultOPT = conf.BaseOPTAddd
	default:
		fmt.Println("没", resultOPT)
		return errors.New("???")
	}


	fmt.Println("resultOPT, resultOPD", resultOPT, resultOPD)
	u.PushBack(OPD, resultOPD)
	u.PushBack(OPT, resultOPT)
	return nil
}
